/**
 * JavaScript 长整型精度处理工具
 * 解决前后端交互中长整型ID精度丢失问题
 */

import { longIntConfig, isIdField, debugLog } from "@/config/longIntConfig";

// JavaScript 安全整数范围
const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER; // 9007199254740991
const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER; // -9007199254740991

/**
 * 检查数字是否在安全整数范围内
 */
export function isSafeInteger(num: number): boolean {
  return Number.isSafeInteger(num);
}

/**
 * 安全转换字符串为整数（保持大整数为字符串）
 */
export function safeParseInt(value: string | number): string | number {
  if (typeof value === 'number') {
    // 如果是数字且在安全范围内，返回数字
    if (isSafeInteger(value)) {
      return Math.floor(value);
    }
    // 超出安全范围，转为字符串
    return value.toString();
  }
  
  if (typeof value === 'string') {
    const parsed = parseInt(value, 10);
    if (isNaN(parsed)) {
      console.warn(`无法解析为整数: ${value}`);
      return "0";
    }
    
    // 检查原始字符串表示的数字是否在安全范围内
    if (value.length > 15 || !isSafeInteger(parsed)) {
      // 大整数保持字符串格式
      return value;
    }
    
    return parsed;
  }
  
  return "0";
}

/**
 * 智能检测是否为大整数（基于数值大小和字段名）
 */
function isLikelyLongInteger(key: string, value: string | number): boolean {
  // 1. 基于字段名检测
  if (isIdField(key)) {
    return true;
  }
  
  // 2. 基于数值大小检测
  if (typeof value === 'string') {
    // 纯数字字符串且长度超过10位，很可能是长整数ID
    if (/^\d+$/.test(value) && value.length > 10) {
      return true;
    }
  }
  
  if (typeof value === 'number') {
    // 数值超出JavaScript安全整数范围
    if (!isSafeInteger(value)) {
      return true;
    }
  }
  
  return false;
}

/**
 * 递归处理对象中的长整型字段
 * 智能检测并处理可能的长整型字段
 */
export function processLongIntegers(obj: any): any {
  if (obj === null || obj === undefined) {
    return obj;
  }

  // 处理数组
  if (Array.isArray(obj)) {
    return obj.map(item => processLongIntegers(item));
  }

  // 处理对象
  if (typeof obj === 'object') {
    const processed: any = {};
    
    for (const [key, value] of Object.entries(obj)) {
      // 智能检测是否需要处理长整型
      if ((typeof value === 'string' || typeof value === 'number') && isLikelyLongInteger(key, value)) {
        // 对长整型字段进行安全转换
        const convertedValue = safeParseInt(value);
        processed[key] = convertedValue;
        debugLog(`智能转换长整型字段: ${key} = ${value} -> ${convertedValue}`);
      } else if (typeof value === 'object') {
        // 递归处理嵌套对象
        processed[key] = processLongIntegers(value);
      } else {
        processed[key] = value;
      }
    }
    
    return processed;
  }

  return obj;
}

/**
 * 处理请求数据中的长整型字段
 * 在发送请求前调用
 */
export function processRequestData(data: any): any {
  return processLongIntegers(data);
}

/**
 * 处理响应数据中的长整型字段
 * 在接收响应后调用（如果后端返回的是字符串格式的长整型）
 */
export function processResponseData(data: any): any {
  // 通常后端会将长整型作为字符串返回，这里可以选择是否转换
  // 如果后端已经正确处理了长整型，这里可能不需要处理
  return data;
}

/**
 * 专门处理ID数组的工具函数
 */
export function processIdArray(ids: (string | number)[]): (string | number)[] {
  return ids.map(id => safeParseInt(id));
}

/**
 * 格式化长整型为字符串（用于显示）
 */
export function formatLongInt(value: number | string): string {
  if (typeof value === 'number') {
    return value.toString();
  }
  return value;
}